பைதான் Flask API உருவாக்கம்: RESTful சேவைகளை உருவாக்குவதற்கான விரிவான வழிகாட்டி

நவீன டிஜிட்டல் சூழலில், அப்ளிகேஷன் நிரலாக்க இடைமுகங்கள் (APIs) என்பது வேறுபட்ட மென்பொருள் அமைப்புகளைத் தொடர்பு கொள்ள அனுமதிக்கும் அடிப்படையான இணைப்பு திசு ஆகும். அவை மொபைல் பயன்பாடுகள் முதல் சிக்கலான மைக்ரோசர்வீஸ் கட்டமைப்புகள் வரை அனைத்தையும் இயக்குகின்றன. பல்வேறு API வடிவமைப்பு முன்னுதாரணங்களில், REST (பிரதிநிதித்துவ நிலை பரிமாற்றம்) அதன் எளிமை, அளவிடுதல் மற்றும் நிலையற்ற தன்மை காரணமாக உண்மையான தரநிலையாக உருவெடுத்துள்ளது.

வலுவான மற்றும் திறமையான பின்தள சேவைகளை உருவாக்க விரும்பும் டெவலப்பர்களுக்கு, பைதான் மற்றும் Flask ஆகியவற்றின் கலவையானது ஒரு விதிவிலக்கான தளத்தை வழங்குகிறது. பைத்தானின் சுத்தமான தொடரியல் மற்றும் விரிவான நூலகங்கள் விரைவான வளர்ச்சியை ஏற்படுத்துகின்றன, அதே நேரத்தில் Flask, ஒரு இலகுரக மற்றும் நெகிழ்வான வலை கட்டமைப்பு, ஒரு கடுமையான கட்டமைப்பை விதிக்காமல் சக்திவாய்ந்த APIகளை உருவாக்க தேவையான கருவிகளை வழங்குகிறது. இந்த வழிகாட்டி உலகளாவிய டெவலப்பர்களுக்கானது, பின்தள உருவாக்கத்திற்கு புதியவர்கள் முதல் API உருவாக்கத்திற்கான Flask ஐ தேர்ச்சி பெற விரும்பும் அனுபவம் வாய்ந்த நிரலாளர்கள் வரை அனைவருக்கும் பொருந்தும்.

RESTful API என்றால் என்ன?

நாங்கள் குறியீட்டில் நுழைவதற்கு முன், எங்கள் வளர்ச்சியை வழிநடத்தும் கொள்கைகளை புரிந்துகொள்வது அவசியம். RESTful API என்பது REST கட்டமைப்பு பாணியின் கட்டுப்பாடுகளை கடைபிடிக்கும் ஒரு API ஆகும். இது ஒரு கண்டிப்பான நெறிமுறை அல்ல, ஆனால் அளவிடக்கூடிய, நிலையற்ற மற்றும் நம்பகமான வலை சேவைகளை உருவாக்குவதற்கான வழிகாட்டுதல்களின் தொகுப்பாகும்.

REST இன் முக்கிய கோட்பாடுகள் பின்வருமாறு:

• கிளையன்ட்-சேவையக கட்டமைப்பு: கிளையன்ட் (எ.கா., ஒரு மொபைல் பயன்பாடு அல்லது ஒரு வலை உலாவி) மற்றும் சேவையகம் ஆகியவை ஒரு நெட்வொர்க்கில் தொடர்பு கொள்ளும் தனித்தனி நிறுவனங்கள். இந்த அக்கறைகளின் பிரிப்பு ஒவ்வொரு பகுதியும் சுயாதீனமாக உருவாக அனுமதிக்கிறது.
• நிலையின்மை: சேவையகத்திற்கான கிளையண்டின் ஒவ்வொரு கோரிக்கையும் கோரிக்கையைப் புரிந்துகொள்ளவும் செயலாக்கவும் தேவையான அனைத்து தகவல்களையும் கொண்டிருக்க வேண்டும். சேவையகம் கோரிக்கைகளுக்கு இடையில் எந்த கிளையன்ட் சூழலையும் அல்லது அமர்வு நிலையையும் சேமிக்காது.
• ஒருங்கிணைந்த இடைமுகம்: இது கட்டிடக்கலையை எளிதாக்கும் மற்றும் பிரிக்கிறது. இது நான்கு கட்டுப்பாடுகளைக் கொண்டுள்ளது:
  • வளம் சார்ந்தவை: வளங்கள் (எ.கா., ஒரு பயனர், ஒரு தயாரிப்பு) URIகள் (ஒருங்கிணைந்த வள அடையாளங்காட்டிகள்) மூலம் அடையாளம் காணப்படுகின்றன. உதாரணமாக, /users/123 ஒரு குறிப்பிட்ட பயனரை அடையாளம் காட்டுகிறது.
  • நிலையான HTTP முறைகள்: கிளையண்டுகள் நிலையான முறைகளின் (வினைச்சொற்கள்) நிலையான தொகுப்பைப் பயன்படுத்தி வளங்களைக் கையாளுகின்றன, அதாவது GET (திரும்பப் பெறு), POST (உருவாக்கு), PUT (புதுப்பிப்பு/மாற்று), மற்றும் DELETE (நீக்கு).
  • சுய-விளக்க செய்திகள்: ஒவ்வொரு செய்தியிலும் அதை எவ்வாறு செயலாக்குவது என்பதை விவரிக்க போதுமான தகவல்கள் உள்ளன, பெரும்பாலும் application/json போன்ற மீடியா வகைகள் மூலம்.
  • ஹைப்பர்மீடியா பயன்பாட்டு நிலை இயந்திரமாக (HATEOAS): இந்த மேம்பட்ட கருத்து ஒரு கிளையன்ட் API இன் பதில்களில் வழங்கப்பட்ட ஹைப்பர்லிங்க்ஸ் மூலம் கிடைக்கக்கூடிய அனைத்து செயல்களையும் வளங்களையும் கண்டறிய முடியும் என்று கூறுகிறது.
• சேமிப்புத்திறன்: செயல்திறன் மற்றும் அளவிடுதலை மேம்படுத்த, பதில்கள் தங்களை மறைமுகமாகவோ அல்லது வெளிப்படையாகவோ தற்காலிக சேமிக்கக்கூடியவை அல்லது தற்காலிக சேமிக்க முடியாதவை என வரையறுக்க வேண்டும்.

பைதான் மற்றும் Flask ஐ ஏன் தேர்வு செய்ய வேண்டும்?

பைதான் பல காரணங்களுக்காக பின்தள உருவாக்கத்தில் ஒரு ஆதிக்க சக்தியாக மாறியுள்ளது:

• எளிதில் படிக்கும் தன்மை மற்றும் எளிமை: பைத்தானின் சுத்தமான தொடரியல் டெவலப்பர்கள் குறைந்த குறியீட்டை எழுதவும் கருத்துக்களை தெளிவாக வெளிப்படுத்தவும் அனுமதிக்கிறது, இது நீண்டகால பராமரிப்புக்கு விலைமதிப்பற்றது.
• பரந்த சுற்றுச்சூழல் அமைப்பு: Flask, Django, FastAPI போன்ற நூலகங்கள் மற்றும் கட்டமைப்புகளின் வளமான சுற்றுச்சூழல் அமைப்பு மற்றும் தரவு அறிவியல், இயந்திர கற்றல் மற்றும் பலவற்றிற்கான கருவிகள் எளிதாக ஒருங்கிணைக்க அனுமதிக்கின்றன.
• வலுவான சமூகம்: ஒரு பெரிய, செயலில் உள்ள உலகளாவிய சமூகம் சிறந்த ஆவணங்கள், பயிற்சிகள் மற்றும் ஆதரவு எப்போதும் கிடைக்கும் என்று அர்த்தம்.

குறிப்பாக, Flask API உருவாக்கத்திற்கு ஒரு சிறந்த தேர்வு:

• மைக்ரோ-கட்டமைப்பு: இது ஒரு குறிப்பிட்ட திட்ட அமைப்பு அல்லது சார்புகளை கட்டாயப்படுத்தாமல் வலை உருவாக்கத்திற்கான முக்கிய கூறுகளை (ரூட்டிங், கோரிக்கை கையாளுதல், டெம்ப்ளேட்டிங்) வழங்குகிறது. நீங்கள் சிறியதாகத் தொடங்கி உங்களுக்குத் தேவையானதை மட்டும் சேர்க்கவும்.
• நெகிழ்வுத்தன்மை: Flask உங்களுக்கு முழு கட்டுப்பாட்டையும் வழங்குகிறது, தனிப்பயன் தீர்வுகள் மற்றும் மைக்ரோசர்வீஸ்களை உருவாக்குவதற்கு இது சரியானது.
• விரிவாக்கக்கூடியது: தரவுத்தள ஒருங்கிணைப்பு (Flask-SQLAlchemy), அங்கீகாரம் (Flask-Login, Flask-JWT-Extended) மற்றும் API உருவாக்கம் (Flask-RESTX) போன்ற செயல்பாடுகளைச் சேர்க்க ஏராளமான உயர்தர நீட்டிப்புகள் உள்ளன.

பகுதி 1: உங்கள் மேம்பாட்டு சூழலை அமைத்தல்

எங்கள் பணியிடத்தை தயாரிப்பதன் மூலம் ஆரம்பிக்கலாம். எந்தவொரு தொழில்முறை திட்டத்திற்கும் சுத்தமான, தனிமைப்படுத்தப்பட்ட சூழல் முக்கியமானது.

முன்தேவைகள்

உங்கள் கணினியில் பைதான் 3.6 அல்லது அதற்குப் பிந்தையது நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். உங்கள் டெர்மினல் அல்லது கட்டளை வரியில் பின்வரும் கட்டளையை இயக்குவதன் மூலம் இதைச் சரிபார்க்கலாம்:

python --version அல்லது python3 --version

மெய்நிகர் சூழலை உருவாக்குதல்

மெய்நிகர் சூழல் என்பது உங்கள் பைதான் திட்டத்தின் சார்புகளுக்கான ஒரு தனிமைப்படுத்தப்பட்ட இடமாகும். இது ஒரே இயந்திரத்தில் வெவ்வேறு திட்டங்களுக்கு இடையே ஏற்படும் மோதல்களைத் தடுக்கிறது. இது பேச்சுவார்த்தைக்குட்படாத சிறந்த நடைமுறை.

1. உங்கள் திட்டத்திற்கு ஒரு புதிய கோப்பகத்தை உருவாக்கி, அதில் செல்லவும்:

mkdir flask_api_project
cd flask_api_project

2. `venv` என்ற மெய்நிகர் சூழலை உருவாக்கவும்:

python3 -m venv venv

3. மெய்நிகர் சூழலை இயக்கவும். உங்கள் இயக்க முறைமையின் அடிப்படையில் கட்டளை வேறுபடுகிறது:

• macOS/Linux: source venv/bin/activate
• Windows: venv\Scripts\activate

செயல்படுத்தப்பட்டதும், உங்கள் கட்டளை வரியில் `(venv)` முன்னொட்டாகக் காண்பீர்கள், நீங்கள் இப்போது மெய்நிகர் சூழலுக்குள் வேலை செய்கிறீர்கள் என்பதைக் குறிக்கிறது.

Flask ஐ நிறுவுதல்

சுற்றுச்சூழல் செயல்படும் நிலையில், பைத்தானின் தொகுப்பு நிறுவியான `pip` ஐப் பயன்படுத்தி Flask ஐ நிறுவலாம்.

pip install Flask

பகுதி 2: உங்கள் முதல் Flask API முனை

ஒரு APIக்கு ஏற்றவாறு மாற்றியமைக்கப்பட்ட, உன்னதமான "Hello, World!" உதாரணத்துடன் தொடங்குவோம். உங்கள் திட்ட கோப்பகத்தில் app.py என்ற புதிய கோப்பை உருவாக்கவும்.

            
from flask import Flask, jsonify

# Create a Flask application instance
app = Flask(__name__)

# Define a route and its corresponding view function
@app.route('/')
def home():
    # jsonify serializes a Python dictionary to a JSON response
    return jsonify({'message': 'Hello, World!'})

# Run the app if the script is executed directly
if __name__ == '__main__':
    app.run(debug=True)

            

              
                Copy
              
            
          

குறியீட்டை உடைத்தல்

• from flask import Flask, jsonify: எங்கள் பயன்பாட்டை உருவாக்க `Flask` வகுப்பையும், JSON-வடிவ பதில்களை உருவாக்க `jsonify` ஐயும் இறக்குமதி செய்கிறோம்.
• app = Flask(__name__): Flask பயன்பாட்டின் ஒரு நிகழ்வை உருவாக்குகிறோம். __name__ என்பது தற்போதைய தொகுதியின் பெயரைப் பெறும் ஒரு சிறப்பு பைதான் மாறியாகும்.
• @app.route('/'): இது எந்த URL எங்கள் செயல்பாட்டைத் தூண்ட வேண்டும் என்று Flask இடம் சொல்லும் அலங்கரிப்பாளராகும். `/` எங்கள் பயன்பாட்டின் ரூட் URL உடன் ஒத்துள்ளது.
• def home():: இது `/` ரூட்டுக்கு ஒரு கோரிக்கை செய்யப்படும்போது செயல்படுத்தப்படும் காட்சிச் செயல்பாடாகும்.
• return jsonify({'message': 'Hello, World!'}): HTML ஐ திருப்பி அனுப்புவதற்கு பதிலாக, JSON பொருளை திருப்பி அனுப்புகிறோம். jsonify HTTP `Content-Type` தலைப்பை application/json என சரியாக அமைக்கிறது.
• if __name__ == '__main__': app.run(debug=True): தொகுதி இறக்குமதி செய்யப்படும்போது அல்ல, ஸ்கிரிப்ட் நேரடியாக செயல்படுத்தப்படும்போது மட்டுமே மேம்பாட்டு சேவையகம் தொடங்கப்படுவதை இந்தத் தொகுதி உறுதி செய்கிறது. debug=True பிழைத்திருத்த பயன்முறையை செயல்படுத்துகிறது, இது பயனுள்ள பிழை செய்திகளை வழங்குகிறது மற்றும் நீங்கள் குறியீட்டில் மாற்றங்களைச் செய்யும்போது தானாகவே சேவையகத்தை மீண்டும் ஏற்றுகிறது.

பயன்பாட்டை இயக்குதல்

உங்கள் டெர்மினலில் (மெய்நிகர் சூழல் இன்னும் செயல்பாட்டில் உள்ளது), பயன்பாட்டை இயக்கவும்:

python app.py

இதைப் போன்ற வெளியீட்டை நீங்கள் காண வேண்டும்:

* Serving Flask app "app" (lazy loading)
* Environment: development
* Debug mode: on
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

இப்போது, ஒரு வலை உலாவியைத் திறந்து http://127.0.0.1:5000/ க்கு செல்லவும் அல்லது curl அல்லது Postman போன்ற ஒரு கருவியைப் பயன்படுத்தவும். நீங்கள் JSON பதிலை பெறுவீர்கள்:

{ "message": "Hello, World!" }

வாழ்த்துக்கள்! Flask உடன் உங்கள் முதல் API முனை உருவாக்கப்பட்டு இயக்கப்பட்டது.

பகுதி 3: முழு CRUD API ஐ உருவாக்குதல்

CRUD (உருவாக்கு, படிக்க, புதுப்பிக்க, நீக்க) API என்பது பெரும்பாலான வலை சேவைகளின் அடித்தளமாகும். பணிகளின் தொகுப்பை நிர்வகிக்க ஒரு API ஐ உருவாக்குவோம். விஷயங்களை எளிமையாக வைத்திருக்க, எங்கள் தரவுத்தளமாக நினைவகத்தில் உள்ள அகராதிகளின் பட்டியலைப் பயன்படுத்துவோம். நிஜ உலக பயன்பாட்டில், இதை PostgreSQL அல்லது MySQL போன்ற சரியான தரவுத்தளத்துடன் மாற்றுவீர்கள்.

பின்வரும் குறியீட்டின் மூலம் உங்கள் app.py ஐப் புதுப்பிக்கவும்:

            
from flask import Flask, jsonify, request

app = Flask(__name__)

# In-memory 'database'
tasks = [
    {
        'id': 1,
        'title': 'Learn Python',
        'description': 'Study the basics of Python syntax and data structures.',
        'done': True
    },
    {
        'id': 2,
        'title': 'Build a Flask API',
        'description': 'Create a simple RESTful API using the Flask framework.',
        'done': False
    }
]

# Helper function to find a task by ID
def find_task(task_id):
    return next((task for task in tasks if task['id'] == task_id), None)

# --- READ --- #
# GET all tasks
@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({'tasks': tasks})

# GET a single task
@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = find_task(task_id)
    if task is None:
        return jsonify({'error': 'Task not found'}), 404
    return jsonify({'task': task})

# --- CREATE --- #
# POST a new task
@app.route('/tasks', methods=['POST'])
def create_task():
    if not request.json or not 'title' in request.json:
        return jsonify({'error': 'The new task must have a title'}), 400
    
    new_task = {
        'id': tasks[-1]['id'] + 1 if tasks else 1,
        'title': request.json['title'],
        'description': request.json.get('description', ""),
        'done': False
    }
    tasks.append(new_task)
    return jsonify({'task': new_task}), 201 # 201 Created status

# --- UPDATE --- #
# PUT to update a task
@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = find_task(task_id)
    if task is None:
        return jsonify({'error': 'Task not found'}), 404
    
    if not request.json:
        return jsonify({'error': 'Request must be JSON'}), 400
    
    # Update fields
    task['title'] = request.json.get('title', task['title'])
    task['description'] = request.json.get('description', task['description'])
    task['done'] = request.json.get('done', task['done'])
    
    return jsonify({'task': task})

# --- DELETE --- #
# DELETE a task
@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = find_task(task_id)
    if task is None:
        return jsonify({'error': 'Task not found'}), 404
    
    tasks.remove(task)
    return jsonify({'result': True})

if __name__ == '__main__':
    app.run(debug=True)

            

              
                Copy
              
            
          

CRUD முனைகளை சோதித்தல்

`POST`, `PUT`, மற்றும் `DELETE` கோரிக்கைகளுக்கு குறிப்பாக, இந்த முனைகளை திறம்பட சோதிக்க Postman போன்ற API கிளையன்ட் அல்லது curl போன்ற கட்டளை-வரி கருவி உங்களுக்குத் தேவைப்படும்.

1. அனைத்து பணிகளையும் பெறுதல் (GET)

• முறை: GET
• URL: http://127.0.0.1:5000/tasks
• முடிவு: அனைத்து பணிகளின் பட்டியலைக் கொண்ட ஒரு JSON பொருள்.

2. ஒரு பணியை பெறுதல் (GET)

• முறை: GET
• URL: http://127.0.0.1:5000/tasks/1
• முடிவு: ஐடி 1 உடன் பணி. 99 போன்ற இல்லாத ஐடியை நீங்கள் முயற்சித்தீர்கள் என்றால், 404 கிடைக்கவில்லை பிழை கிடைக்கும்.

3. ஒரு புதிய பணியை உருவாக்குதல் (POST)

• முறை: POST
• URL: http://127.0.0.1:5000/tasks
• தலைப்புகள்: Content-Type: application/json
• உடல் (raw JSON): { "title": "Read a book", "description": "Finish reading 'Designing Data-Intensive Applications'." }
• முடிவு: ஒதுக்கப்பட்ட ஐடியுடன் புதிதாக உருவாக்கப்பட்ட பணி பொருளுடன் 201 உருவாக்கப்பட்ட நிலை.

4. தற்போதுள்ள பணியைப் புதுப்பித்தல் (PUT)

• முறை: PUT
• URL: http://127.0.0.1:5000/tasks/2
• தலைப்புகள்: Content-Type: application/json
• உடல் (raw JSON): { "done": true }
• முடிவு: ஐடி 2 க்கான புதுப்பிக்கப்பட்ட பணி பொருள், இப்போது `done` `true` க்கு அமைக்கப்பட்டுள்ளது.

5. ஒரு பணியை நீக்குதல் (DELETE)

• முறை: DELETE
• URL: http://127.0.0.1:5000/tasks/1
• முடிவு: உறுதிப்படுத்தல் செய்தி. பின்னர் நீங்கள் அனைத்து பணிகளையும் பெற முயற்சித்தீர்கள் என்றால், ஐடி 1 உடன் பணி போய்விடும்.

பகுதி 4: சிறந்த நடைமுறைகள் மற்றும் மேம்பட்ட கருத்துகள்

இப்போது உங்களிடம் ஒரு செயல்பாட்டு CRUD API உள்ளது, அதை எவ்வாறு தொழில்முறை, வலுவான மற்றும் அளவிடக்கூடியதாக மாற்றுவது என்பதை ஆராய்வோம்.

நீல அச்சிட்டுகளுடன் சரியான திட்ட அமைப்பு

உங்கள் API வளரும்போது, உங்கள் அனைத்து வழித்தடங்களையும் ஒரே `app.py` கோப்பில் வைப்பது கட்டுப்பாடற்றதாகிவிடும். Flask இன் நீல அச்சிட்டுகள் உங்கள் பயன்பாட்டை சிறிய, மீண்டும் பயன்படுத்தக்கூடிய கூறுகளாக ஒழுங்கமைக்க உங்களை அனுமதிக்கின்றன.

இது போன்ற ஒரு கட்டமைப்பை நீங்கள் உருவாக்கலாம்:

/my_api
  /venv
  /app
    /__init__.py       # App factory
    /routes
      /__init__.py
      /tasks.py         # Blueprint for task routes
    /models.py          # Database models (if using a DB)
  /run.py             # Script to run the app
  /config.py

நீல அச்சிட்டுகளைப் பயன்படுத்துவது அக்கறைகளைப் பிரிப்பதில் உதவுகிறது மற்றும் உங்கள் குறியீட்டை உலகளாவிய அணிக்கு மிகவும் சுத்தமாகவும், பராமரிக்க எளிதாகவும் ஆக்குகிறது.

மையப்படுத்தப்பட்ட பிழை கையாளுதல்

ஒவ்வொரு பாதையிலும் `None` ஐ சரிபார்க்குவதற்கு பதிலாக, நீங்கள் மையப்படுத்தப்பட்ட பிழை கையாளுபவர்களை உருவாக்கலாம். உங்கள் API எப்போதும் நிலையான, நன்கு வடிவமைக்கப்பட்ட JSON பிழை பதில்களை வழங்கும் என்பதை இது உறுதி செய்கிறது.

            
@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Not Found', 'message': 'The requested resource was not found on the server.'}), 404

@app.errorhandler(400)
def bad_request(error):
    return jsonify({'error': 'Bad Request', 'message': 'The server could not understand the request due to invalid syntax.'}), 400

            

              
                Copy
              
            
          

முழு API முழுவதும் பிழைகளை பிடிக்க இந்த கையாளுபவர்களை உங்கள் முக்கிய பயன்பாட்டு கோப்பில் வைப்பீர்கள்.

HTTP நிலை குறியீடுகளின் முக்கியத்துவம்

நன்கு வடிவமைக்கப்பட்ட REST API க்கு சரியான HTTP நிலை குறியீடுகளைப் பயன்படுத்துவது முக்கியமானது. அவர்களின் கோரிக்கைகளின் விளைவு குறித்து அவர்கள் வாடிக்கையாளர்களுக்கு உடனடி, தரப்படுத்தப்பட்ட கருத்தை வழங்குகிறார்கள். இங்கே சில முக்கியமானவை:

• 200 சரி: கோரிக்கை வெற்றிகரமாக இருந்தது (GET, PUT க்கு பயன்படுத்தப்படுகிறது).
• 201 உருவாக்கப்பட்டது: ஒரு புதிய வளம் வெற்றிகரமாக உருவாக்கப்பட்டது (POST க்கு பயன்படுத்தப்படுகிறது).
• 204 உள்ளடக்கம் இல்லை: கோரிக்கை வெற்றிகரமாக இருந்தது, ஆனால் திருப்பி அனுப்ப எந்த உள்ளடக்கமும் இல்லை (அடிக்கடி DELETE க்கு பயன்படுத்தப்படுகிறது).
• 400 தவறான கோரிக்கை: ஒரு கிளையன்ட் பிழை காரணமாக சேவையகம் கோரிக்கையை செயலாக்க முடியாது (எ.கா., மோசமான JSON).
• 401 அங்கீகரிக்கப்படவில்லை: கோரப்பட்ட பதிலை பெற கிளையன்ட் தன்னை அங்கீகரிக்க வேண்டும்.
• 403 தடைசெய்யப்பட்டது: கிளையண்டிற்கு உள்ளடக்கத்திற்கான அணுகல் உரிமைகள் இல்லை.
• 404 கிடைக்கவில்லை: சேவையகம் கோரப்பட்ட வளத்தைக் கண்டுபிடிக்க முடியவில்லை.
• 500 உள் சேவையக பிழை: கோரிக்கையை நிறைவேற்றுவதைத் தடுத்த எதிர்பாராத சூழ்நிலையை சேவையகம் சந்தித்தது.

API பதிப்பு

உங்கள் API உருவாகும்போது, நீங்கள் தவிர்க்க முடியாமல் உடைக்கும் மாற்றங்களை அறிமுகப்படுத்த வேண்டும். ஏற்கனவே உள்ள வாடிக்கையாளர்களுக்கு இடையூறு ஏற்படுவதைத் தவிர்க்க, உங்கள் API ஐ பதிப்பிக்க வேண்டும். URL இல் பதிப்பு எண்ணைச் சேர்ப்பது ஒரு பொதுவான மற்றும் நேரடியான அணுகுமுறை.

உதாரணமாக: /api/v1/tasks பின்னர் /api/v2/tasks.

API இன் ஒவ்வொரு பதிப்பும் அதன் சொந்த நீல அச்சிட்டாக இருக்கும் நீல அச்சிட்டுகளைப் பயன்படுத்தி இதை Flask இல் எளிதாக நிர்வகிக்க முடியும்.

Flask நீட்டிப்புகளைப் பயன்படுத்துதல்

Flask இன் உண்மையான சக்தி அதன் விரிவாக்கத்தன்மையில் உள்ளது. தொழில்முறை API உருவாக்கத்திற்கு இன்றியமையாத சில நீட்டிப்புகள் இங்கே:

• Flask-SQLAlchemy: Flask உடன் SQLAlchemy Object Relational Mapper (ORM) ஐப் பயன்படுத்துவதை எளிதாக்கும் ஒரு நீட்டிப்பு, தரவுத்தள தொடர்புகளை தடையற்றதாக ஆக்குகிறது.
• Flask-Migrate: Alembic ஐப் பயன்படுத்தி SQLAlchemy தரவுத்தள இடப்பெயர்வுகளைக் கையாளுகிறது, உங்கள் பயன்பாடு மாறும்போது உங்கள் தரவுத்தள ஸ்கீமாவை உருவாக்க உங்களை அனுமதிக்கிறது.
• Flask-Marshmallow: பொருள் வரிசைக்கு (தரவுத்தள மாதிரிகள் போன்ற சிக்கலான பொருட்களை JSON ஆக மாற்றுதல்) மற்றும் வரிசை நீக்கம் (உள்வரும் JSON ஐ சரிபார்த்து பயன்பாட்டு பொருட்களாக மாற்றுதல்) Marshmallow நூலகத்தை ஒருங்கிணைக்கிறது.
• Flask-RESTX: கோரிக்கை பகுப்பாய்வு, உள்ளீட்டு சரிபார்ப்பு மற்றும் Swagger UI உடன் ஊடாடும் API ஆவணங்களை தானாக உருவாக்குதல் போன்ற அம்சங்களை வழங்கும் REST API களை உருவாக்குவதற்கான சக்திவாய்ந்த நீட்டிப்பு.

பகுதி 5: உங்கள் API ஐப் பாதுகாத்தல்

பாதுகாப்பற்ற API என்பது ஒரு குறிப்பிடத்தக்க பொறுப்பு. API பாதுகாப்பு என்பது ஒரு பரந்த தலைப்பு என்றாலும், நீங்கள் கருத்தில் கொள்ள வேண்டிய இரண்டு அடிப்படை கருத்துக்கள் இங்கே.

அங்கீகாரம்

அங்கீகாரம் என்பது ஒரு பயனர் யார் என்பதை சரிபார்க்கும் செயல்முறையாகும். பொதுவான உத்திகள் பின்வருமாறு:

• API விசைகள்: ஒரு கிளையன்ட் ஒவ்வொரு கோரிக்கையுடன் அனுப்பும் ஒரு எளிய டோக்கன், பொதுவாக ஒரு தனிப்பயன் HTTP தலைப்பில் (எ.கா., `X-API-Key`).
• அடிப்படை அங்கீகாரம்: கிளையன்ட் `அங்கீகாரம்` தலைப்பில் அடிப்படை 64-குறியிடப்பட்ட பயனர்பெயர் மற்றும் கடவுச்சொல்லை அனுப்புகிறது. இது HTTPS இல் மட்டுமே பயன்படுத்தப்பட வேண்டும்.
• JWT (JSON வலை டோக்கன்கள்): ஒரு நவீன, நிலையற்ற அணுகுமுறை, அங்கு ஒரு கிளையன்ட் கையொப்பமிடப்பட்ட டோக்கனைப் பெற சான்றுகளுடன் அங்கீகரிக்கிறது. இந்த டோக்கன் பின்னர் `அங்கீகாரம்` தலைப்பில் அடுத்தடுத்த கோரிக்கைகளுடன் அனுப்பப்படுகிறது (எ.கா., `Authorization: Bearer `). Flask-JWT-Extended விரிவாக்கம் இதற்கு சிறந்தது.

CORS (குறுக்கு மூல வள பகிர்வு)

இயல்பாக, வலை உலாவிகள் அதே மூலக் கொள்கையை செயல்படுத்துகின்றன, இது ஒரு வலைப்பக்கம் பக்கத்தை வழங்கியதை விட வேறு களத்திற்கான கோரிக்கைகளை செய்வதிலிருந்து தடுக்கிறது. உங்கள் API `api.example.com` இல் ஹோஸ்ட் செய்யப்பட்டிருந்தால் மற்றும் உங்கள் வலை முன் `app.example.com` இல் இருந்தால், உலாவி கோரிக்கைகளை தடுக்கும். CORS என்பது கூடுதல் HTTP தலைப்புகளைப் பயன்படுத்தும் ஒரு பொறிமுறையாகும், இது ஒரு மூலத்தில் இயங்கும் வலை பயன்பாட்டிற்கு, வேறு மூலத்திலிருந்து தேர்ந்தெடுக்கப்பட்ட ஆதாரங்களுக்கான அணுகலைக் கொடுக்கும்படி உலாவிகளுக்கு சொல்லும். Flask-CORS விரிவாக்கம் இதை செயல்படுத்துவதையும் கட்டமைப்பதையும் நேராக ஆக்குகிறது.

முடிவு

பைதான் மற்றும் Flask உடன் முழுமையான, செயல்பாட்டு CRUD API ஐ உருவாக்குவதற்கான REST இன் அடிப்படை கருத்துகளிலிருந்து நீங்கள் இப்போது பயணம் செய்துள்ளீர்கள். உங்கள் சூழலை அமைப்பது, முனைகளை உருவாக்குவது, வெவ்வேறு HTTP முறைகளைக் கையாளுவது மற்றும் திட்ட அமைப்பு, பிழை கையாளுதல் மற்றும் பாதுகாப்பு போன்ற சிறந்த நடைமுறைகளை ஆராய்வது பற்றி நாங்கள் விவாதித்தோம்.

பைதான் மற்றும் Flask API உருவாக்கத்திற்கான ஒரு பயங்கரமான ஆனால் அணுகக்கூடிய அடுக்கு ஆகும். இதன் எளிமை விரைவான முன்மாதிரிக்கு அனுமதிக்கிறது, அதே நேரத்தில் அதன் நெகிழ்வுத்தன்மை மற்றும் விரிவாக்கங்களின் வளமான சுற்றுச்சூழல் அமைப்பு உலகளாவிய பயனர் தளத்திற்கு சேவை செய்யக்கூடிய சிக்கலான, உற்பத்தி-தயார் மற்றும் அளவிடக்கூடிய மைக்ரோசர்வீஸ்களை உருவாக்க உதவுகிறது. உங்கள் பயணத்தின் அடுத்த படிகள் ஒரு உண்மையான தரவுத்தளத்தை ஒருங்கிணைத்தல், உங்கள் முனைகளுக்கான தானியங்கி சோதனைகளை எழுதுதல் மற்றும் உங்கள் பயன்பாட்டை ஒரு மேகக்கணி தளத்தில் பயன்படுத்துதல் ஆகியவை அடங்கும். நீங்கள் இங்கே கட்டிய அடித்தளம் உறுதியானது, மற்றும் சாத்தியக்கூறுகள் வரம்பற்றவை.